Programming Elixir : Foundational Functional Transformations

In Elixir, computation is viewed as a series of foundational transformations. Data is immutable, and the = operator is not for assignment, but for pattern matching.

1. The Match Operator

Matching allows you to bind values to patterns. If the structure of the left side doesn't match the right, the transformation fails. Elixir uses specialized operators for data flow: Arithmetic (+, -, *, /), Comparison (===, !==, >=), and Join (<> for strings, ++ for lists).

2. The 'with' Expression

The with expression orchestrates multi-step transformations where success is conditional. It allows chaining matches using <-. Unlike the match operator =, if a match in <- fails, the expression returns the non-matching value instead of raising an error.

3. Scoping and Syntax

Under the hood, with is treated as a macro or function call. Variables bound within it do not leak into the outer scope. Syntax like mean = with count = ..., do: sum/count is the expression-based way to calculate derived values.

$$\text{mean} = \frac{\sum_{i=1}^{n} x_i}{n}$$

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

In Elixir, what does the = operator represent?

Assignment of a value to a memory location.

Pattern matching between the left and right sides.

Pointer referencing.

Boolean equivalence check only.

QUESTION 2

What is the primary difference between = and <-with expression?

There is no difference; they are interchangeable.

<-= returns nil.

<-= raises a MatchError.

= is only for arithmetic, <-

✅ Correct!

The <-with block provides a safe way to handle failed matches by ejecting the non-matching value.

❌ Incorrect

The = operator inside with will still crash the process if the match fails.

QUESTION 3

Which operator is used for list concatenation?

+

<>

++

append

✅ Correct!

The ++ operator joins two lists together.

❌ Incorrect

<> is for binaries/strings, and + is strictly for arithmetic.

QUESTION 4

How does Elixir represent the strict equality check (value and type)?

==

===

eq

equals?

✅ Correct!

=== checks both value and type (e.g., 1 === 1.0 is false).

❌ Incorrect

== is value-based equality (e.g., 1 == 1.0 is true).

QUESTION 5

Which function acts as a 'gatekeeper' to verify a value is an atom?

check_atom

is_atom

atom?

type_atom

✅ Correct!

is_atom is a built-in type-check guard/function.

❌ Incorrect

Standard type-check functions in Elixir start with is_.

Module & Function Transformations

Practical exercises in anonymous functions and recursion

You are tasked with implementing fundamental utilities in IEx and modules. These functions will handle list manipulation, mathematical algorithms (GCD), and string transformations (Caesar cipher).

1. Go into IEx. Create and run anonymous functions that do the following: list_concat.([:a, :b], [:c, :d]), sum.(1, 2, 3), pair_tuple_to_list.( { 1234, 5678 } )

Solution:
Solution: - list_concat = fn (a, b) -> a ++ b end - sum = fn (a, b, c) -> a + b + c end - pair_tuple_to_list = fn ({a, b}) -> [a, b] end

2. Exercise: ModulesAndFunctions-5. Write a function gcd(x,y) that finds the greatest common divisor between two nonnegative integers. Algebraically, gcd(x,y) is x if y is zero; it's gcd(y, rem(x,y)) otherwise.

Solution:
Solution:

defmodule MyMath do
  def gcd(x, 0), do: x
  def gcd(x, y), do: gcd(y, rem(x, y))
end

3. Exercise: ListsAndRecursion-3. Write a caesar(list, n) function that adds n to each list element (character code), wrapping if the addition results in a character greater than 'z'.

Solution:
Solution:

defmodule MyList do
  def caesar([], _n), do: []
  def caesar([ head | tail ], n) when head + n <= ?z, do: [ head + n | caesar(tail, n) ]
  def caesar([ head | tail ], n), do: [ head + n - 26 | caesar(tail, n) ]
end